Towards Verification via Supercompilation

Supercompilation, or Supervised Compilation is a technique for program specialization, optimization and, more generally, program transformation. We present an idea to use supercompilation for verification of parameterized programs and protocols, present a case study and report on our initial experiments. 1 Supercompilation and Verification Verification of infinite-state or parameterized systems is challenging and, in general, an undecidable problem. The research in this area is still very active and taking various routes, including development of deductive methods and parameterized model checking. This abstract describes our ongoing work on developing a new alternative approach for reasoning about and verification of parameterized systems. The approach uses the program transformation methods known as supercompilation. The supercompilation (from supervised compilation) is a powerful semantic based program transformation technique [6, 8] having a long history well back to the 196070s, when it was proposed by V. Turchin. The main idea of supercompilation may be explained as follows. Let be a functional program implementing a partial function , where is some set of data. A supercompiler observes the behaviour of running on (partially defined) input with the aim to define, based solely on the observations, a program , which would be equivalent to the original one (on the domain of latter), but having improved properties. The result may be a specialized version of the original program, taking into account the properties of known arguments, or just a reformulation, and sometimes more efficient equivalent program. The resulting program is build as the result of metainterpretation of , so and visiting Department of Computer Science, the University of Liverpool, supported by the Research Development Fund, grant RDF 4416 may have nothing common in syntax. As to the semantics, the result of supercompilation implements, in general, an extension1 of , that is a function such that . From the very beginning the development of supercompilation has been conducted mainly in the context of the Refal programming language [7]. A few supercompilers for Refal were implemented with the most advanced being SCP4 [5]. Our idea here, to use supercompilation for the purpose of verification, came from the numerous observations on the results of supercompilation. It is often the case that transformed program is much simpler than original one, and moreover, the attempts to execute a parameterized program2, undertaken by a supercompiler reveal deep properties of the computation of this program, otherwise hidden in the original syntax. Bearing this in mind we came up with the following idea for verification via supercompilation: Take a program/protocol/system to be verified and encode it as a parameterized functional program. Then apply supercompilation in order to get a transformed program for which the correctness condition can be easily checked. In our experiments we have used a particular scheme, which essentially implements a parameterized testing. That is, the above parameterized functional program first models the execution of a system (protocol) for steps (where is an input parameter), and then checks the correctnes condition. For any concrete value of the program tests the correctness condition on the -th step of the execution of the system. 1this distinguishes it from other popular program transformation techniques, such as partial evaluation [3] 2we use somewhat ambiguous, but shorter term parameterized program for denoting a program with the parameterized entry point Proceedings of the 29th Annual International Computer Software and Applications Conference (COMPSAC’05) 0730-3157/05 $20.00 © 2005 IEEE Supercompilation works on programs with parameterized entry points and analyses behaviour of programs for all possible values of input parameters (in our case the parameter is an arbitrary value of the ). The output of supercompilation can be used then to verify safety conditions. Using the programs with parameterized entry points allows also to deal with non-deterministic systems. We model non-determinismby providing another input parameter, taking strings of characters (possible choices) as values.